Dart Basics: Variables, Types, Operators, and I/O

Dart is the language behind Flutter. It is statically typed with type inference, supports sound null safety, and mixes imperative, object-oriented, and functional styles. Mastering basic types and operators makes reading Flutter examples and building app logic straightforward.

Understanding Dart fundamentals is essential because every Flutter widget, every state management pattern, and every piece of business logic you write will use Dart syntax and concepts. The language's design emphasizes clarity, safety, and developer productivity.

Dart provides several built-in data types and multiple ways to declare variables. Understanding these is fundamental to writing effective Dart code.

Variable Declaration Keywords

Code Pattern: Declaration Examples

int count = 10;
double price = 9.99;
String title = 'Mobile Development';
bool isOpen = true;

var name = 'Adu';        // inferred as String
final createdAt = DateTime.now(); // runtime constant
const maxLimit = 100;    // compile-time constant

Dart's null safety feature helps prevent null reference errors, which are a common source of bugs in many programming languages. Understanding null safety is crucial for writing robust Dart code.

Examples

String? nickname;          // can be null
var displayName = nickname ?? 'Guest'; // default to 'Guest'
print(displayName);

Dart provides powerful string manipulation capabilities. You can concatenate strings or use string interpolation for more readable code.

String greeting = 'Hello' + ' ' + 'World';

String first = 'Adu';
String last = 'Amankwah';
String full = '$first $last';        // interpolation
print('Welcome, $full');

Note: String interpolation is generally preferred over concatenation as it's more readable and efficient.

Collections are essential data structures in Dart. Lists store ordered sequences of items, while Maps store key-value pairs.

List

Lists are ordered collections of items. You can create them using list literals or typed constructors:

// List literal
var nums = [1, 2, 3];

// Typed variant
List<String> names = [];

// Accessing elements
print(nums[0]);            // first element (index 0)

Map

Maps store key-value pairs. They're useful for representing structured data:

// Map literal
var person = {'name': 'Adu', 'age': 22};

// Typed variant
Map<String, dynamic> item = {};

// Accessing values
print(person['name']);     // value by key

Dart provides a comprehensive set of operators for performing various operations on values.

Arithmetic Operators

Basic mathematical operations:

• + - Addition
• - - Subtraction
• * - Multiplication
• / - Division (returns double)
• ~/ - Integer division
• % - Modulus (remainder)

int a = 7;
int b = 3;
print(a + b);   // 10
print(a / b);   // 2.3333333333
print(a ~/ b);  // 2 (integer division)
print(a % b);   // 1 (remainder)

Comparison Operators

These operators return bool values:

• == - Equal to
• != - Not equal to
• > - Greater than
• < - Less than
• >= - Greater than or equal to
• <= - Less than or equal to

Logical Operators

• && - Logical AND (both conditions must be true)
• || - Logical OR (at least one condition must be true)
• ! - Logical NOT (negates a boolean value)

Assignment and Compound Operators

• = - Assignment
• += - Add and assign
• -= - Subtract and assign
• *= - Multiply and assign
• /= - Divide and assign
• ??= - Assign if null

Example with Logic

bool hasAccess = (age >= 18) && isOpen;

Dart console I/O uses dart:io. For beginner exercises and quick utilities, use stdin.readLineSync() to read user input.

Example: Read and Print

import 'dart:io';

void main() {
  stdout.write('Enter your name: ');
  String? name = stdin.readLineSync();
  print('Hello, ${name ?? 'Guest'}!');
}

Goal: Prompt user for width and height, compute area, display result.

Example Code

import 'dart:io';

void main() {
  stdout.write('Enter width: ');
  String? w = stdin.readLineSync();
  stdout.write('Enter height: ');
  String? h = stdin.readLineSync();

  // Parse inputs safely
  double width = double.tryParse(w ?? '') ?? 0.0;
  double height = double.tryParse(h ?? '') ?? 0.0;

  double area = width * height;
  print('Area: $area');
}

Wrap logic in functions so code is testable and reusable. Functions allow you to break down complex problems into smaller, manageable pieces.

Pattern

double calculateArea(double w, double h) => w * h;

void main() {
  // get inputs...
  double area = calculateArea(width, height);
  print('Area: $area');
}

Benefits of Functions:

• Reusability: Write once, use multiple times
• Testability: Test functions independently
• Readability: Code becomes more self-documenting
• Maintainability: Changes in one place affect all usages

Avoiding common mistakes will make your Dart code more robust and maintainable.